home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / skbuff.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  32KB  |  1,181 lines
  1. /*
  2.  *    Definitions for the 'struct sk_buff' memory handlers.
  3.  *
  4.  *    Authors:
  5.  *        Alan Cox, <gw4pts@gw4pts.ampr.org>
  6.  *        Florian La Roche, <rzsfl@rz.uni-sb.de>
  7.  *
  8.  *    This program is free software; you can redistribute it and/or
  9.  *    modify it under the terms of the GNU General Public License
  10.  *    as published by the Free Software Foundation; either version
  11.  *    2 of the License, or (at your option) any later version.
  12.  */
  13.  
  14. #ifndef _LINUX_SKBUFF_H
  15. #define _LINUX_SKBUFF_H
  16.  
  17. #include <linux/config.h>
  18. #include <linux/kernel.h>
  19. #include <linux/compiler.h>
  20. #include <linux/time.h>
  21. #include <linux/cache.h>
  22.  
  23. #include <asm/atomic.h>
  24. #include <asm/types.h>
  25. #include <linux/spinlock.h>
  26. #include <linux/mm.h>
  27. #include <linux/highmem.h>
  28. #include <linux/poll.h>
  29. #include <linux/net.h>
  30. #include <net/checksum.h>
  31.  
  32. #define HAVE_ALLOC_SKB        /* For the drivers to know */
  33. #define HAVE_ALIGNABLE_SKB    /* Ditto 8)           */
  34. #define SLAB_SKB         /* Slabified skbuffs        */
  35.  
  36. #define CHECKSUM_NONE 0
  37. #define CHECKSUM_HW 1
  38. #define CHECKSUM_UNNECESSARY 2
  39.  
  40. #define SKB_DATA_ALIGN(X)    (((X) + (SMP_CACHE_BYTES - 1)) & \
  41.                  ~(SMP_CACHE_BYTES - 1))
  42. #define SKB_MAX_ORDER(X, ORDER)    (((PAGE_SIZE << (ORDER)) - (X) - \
  43.                   sizeof(struct skb_shared_info)) & \
  44.                   ~(SMP_CACHE_BYTES - 1))
  45. #define SKB_MAX_HEAD(X)        (SKB_MAX_ORDER((X), 0))
  46. #define SKB_MAX_ALLOC        (SKB_MAX_ORDER(0, 2))
  47.  
  48. /* A. Checksumming of received packets by device.
  49.  *
  50.  *    NONE: device failed to checksum this packet.
  51.  *        skb->csum is undefined.
  52.  *
  53.  *    UNNECESSARY: device parsed packet and wouldbe verified checksum.
  54.  *        skb->csum is undefined.
  55.  *          It is bad option, but, unfortunately, many of vendors do this.
  56.  *          Apparently with secret goal to sell you new device, when you
  57.  *          will add new protocol to your host. F.e. IPv6. 8)
  58.  *
  59.  *    HW: the most generic way. Device supplied checksum of _all_
  60.  *        the packet as seen by netif_rx in skb->csum.
  61.  *        NOTE: Even if device supports only some protocols, but
  62.  *        is able to produce some skb->csum, it MUST use HW,
  63.  *        not UNNECESSARY.
  64.  *
  65.  * B. Checksumming on output.
  66.  *
  67.  *    NONE: skb is checksummed by protocol or csum is not required.
  68.  *
  69.  *    HW: device is required to csum packet as seen by hard_start_xmit
  70.  *    from skb->h.raw to the end and to record the checksum
  71.  *    at skb->h.raw+skb->csum.
  72.  *
  73.  *    Device must show its capabilities in dev->features, set
  74.  *    at device setup time.
  75.  *    NETIF_F_HW_CSUM    - it is clever device, it is able to checksum
  76.  *              everything.
  77.  *    NETIF_F_NO_CSUM - loopback or reliable single hop media.
  78.  *    NETIF_F_IP_CSUM - device is dumb. It is able to csum only
  79.  *              TCP/UDP over IPv4. Sigh. Vendors like this
  80.  *              way by an unknown reason. Though, see comment above
  81.  *              about CHECKSUM_UNNECESSARY. 8)
  82.  *
  83.  *    Any questions? No questions, good.         --ANK
  84.  */
  85.  
  86. #ifdef __i386__
  87. #define NET_CALLER(arg) (*(((void **)&arg) - 1))
  88. #else
  89. #define NET_CALLER(arg) __builtin_return_address(0)
  90. #endif
  91.  
  92. struct net_device;
  93.  
  94. #ifdef CONFIG_NETFILTER
  95. struct nf_conntrack {
  96.     atomic_t use;
  97.     void (*destroy)(struct nf_conntrack *);
  98. };
  99.  
  100. #ifdef CONFIG_BRIDGE_NETFILTER
  101. struct nf_bridge_info {
  102.     atomic_t use;
  103.     struct net_device *physindev;
  104.     struct net_device *physoutdev;
  105. #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
  106.     struct net_device *netoutdev;
  107. #endif
  108.     unsigned int mask;
  109.     unsigned long data[32 / sizeof(unsigned long)];
  110. };
  111. #endif
  112.  
  113. #endif
  114.  
  115. struct sk_buff_head {
  116.     /* These two members must be first. */
  117.     struct sk_buff    *next;
  118.     struct sk_buff    *prev;
  119.  
  120.     __u32        qlen;
  121.     spinlock_t    lock;
  122. };
  123.  
  124. struct sk_buff;
  125.  
  126. /* To allow 64K frame to be packed as single skb without frag_list */
  127. #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
  128.  
  129. typedef struct skb_frag_struct skb_frag_t;
  130.  
  131. struct skb_frag_struct {
  132.     struct page *page;
  133.     __u16 page_offset;
  134.     __u16 size;
  135. };
  136.  
  137. /* This data is invariant across clones and lives at
  138.  * the end of the header data, ie. at skb->end.
  139.  */
  140. struct skb_shared_info {
  141.     atomic_t    dataref;
  142.     unsigned int    nr_frags;
  143.     unsigned short    tso_size;
  144.     unsigned short    tso_segs;
  145.     struct sk_buff    *frag_list;
  146.     skb_frag_t    frags[MAX_SKB_FRAGS];
  147. };
  148.  
  149. /** 
  150.  *    struct sk_buff - socket buffer
  151.  *    @next: Next buffer in list
  152.  *    @prev: Previous buffer in list
  153.  *    @list: List we are on
  154.  *    @sk: Socket we are owned by
  155.  *    @stamp: Time we arrived
  156.  *    @dev: Device we arrived on/are leaving by
  157.  *    @input_dev: Device we arrived on
  158.  *      @real_dev: The real device we are using
  159.  *    @h: Transport layer header
  160.  *    @nh: Network layer header
  161.  *    @mac: Link layer header
  162.  *    @dst: FIXME: Describe this field
  163.  *    @cb: Control buffer. Free for use by every layer. Put private vars here
  164.  *    @len: Length of actual data
  165.  *    @data_len: Data length
  166.  *    @mac_len: Length of link layer header
  167.  *    @csum: Checksum
  168.  *    @__unused: Dead field, may be reused
  169.  *    @cloned: Head may be cloned (check refcnt to be sure)
  170.  *    @pkt_type: Packet class
  171.  *    @ip_summed: Driver fed us an IP checksum
  172.  *    @priority: Packet queueing priority
  173.  *    @users: User count - see {datagram,tcp}.c
  174.  *    @protocol: Packet protocol from driver
  175.  *    @security: Security level of packet
  176.  *    @truesize: Buffer size 
  177.  *    @head: Head of buffer
  178.  *    @data: Data head pointer
  179.  *    @tail: Tail pointer
  180.  *    @end: End pointer
  181.  *    @destructor: Destruct function
  182.  *    @nfmark: Can be used for communication between hooks
  183.  *    @nfcache: Cache info
  184.  *    @nfct: Associated connection, if any
  185.  *    @nfctinfo: Relationship of this skb to the connection
  186.  *    @nf_debug: Netfilter debugging
  187.  *    @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
  188.  *      @private: Data which is private to the HIPPI implementation
  189.  *    @tc_index: Traffic control index
  190.  */
  191.  
  192. struct sk_buff {
  193.     /* These two members must be first. */
  194.     struct sk_buff        *next;
  195.     struct sk_buff        *prev;
  196.  
  197.     struct sk_buff_head    *list;
  198.     struct sock        *sk;
  199.     struct timeval        stamp;
  200.     struct net_device    *dev;
  201.     struct net_device    *input_dev;
  202.     struct net_device    *real_dev;
  203.  
  204.     union {
  205.         struct tcphdr    *th;
  206.         struct udphdr    *uh;
  207.         struct icmphdr    *icmph;
  208.         struct igmphdr    *igmph;
  209.         struct iphdr    *ipiph;
  210.         struct ipv6hdr    *ipv6h;
  211.         unsigned char    *raw;
  212.     } h;
  213.  
  214.     union {
  215.         struct iphdr    *iph;
  216.         struct ipv6hdr    *ipv6h;
  217.         struct arphdr    *arph;
  218.         unsigned char    *raw;
  219.     } nh;
  220.  
  221.     union {
  222.           unsigned char     *raw;
  223.     } mac;
  224.  
  225.     struct  dst_entry    *dst;
  226.     struct    sec_path    *sp;
  227.  
  228.     /*
  229.      * This is the control buffer. It is free to use for every
  230.      * layer. Please put your private variables there. If you
  231.      * want to keep them across layers you have to do a skb_clone()
  232.      * first. This is owned by whoever has the skb queued ATM.
  233.      */
  234.     char            cb[40];
  235.  
  236.     unsigned int        len,
  237.                 data_len,
  238.                 mac_len,
  239.                 csum;
  240.     unsigned char        local_df,
  241.                 cloned,
  242.                 pkt_type,
  243.                 ip_summed;
  244.     __u32            priority;
  245.     unsigned short        protocol,
  246.                 security;
  247.  
  248.     void            (*destructor)(struct sk_buff *skb);
  249. #ifdef CONFIG_NETFILTER
  250.         unsigned long        nfmark;
  251.     __u32            nfcache;
  252.     __u32            nfctinfo;
  253.     struct nf_conntrack    *nfct;
  254. #ifdef CONFIG_NETFILTER_DEBUG
  255.         unsigned int        nf_debug;
  256. #endif
  257. #ifdef CONFIG_BRIDGE_NETFILTER
  258.     struct nf_bridge_info    *nf_bridge;
  259. #endif
  260. #endif /* CONFIG_NETFILTER */
  261. #if defined(CONFIG_HIPPI)
  262.     union {
  263.         __u32        ifield;
  264.     } private;
  265. #endif
  266. #ifdef CONFIG_NET_SCHED
  267.        __u32            tc_index;        /* traffic control index */
  268. #ifdef CONFIG_NET_CLS_ACT
  269.     __u32           tc_verd;               /* traffic control verdict */
  270.     __u32           tc_classid;            /* traffic control classid */
  271. #endif
  272.  
  273. #endif
  274.  
  275.  
  276.     /* These elements must be at the end, see alloc_skb() for details.  */
  277.     unsigned int        truesize;
  278.     atomic_t        users;
  279.     unsigned char        *head,
  280.                 *data,
  281.                 *tail,
  282.                 *end;
  283. };
  284.  
  285. #ifdef __KERNEL__
  286. /*
  287.  *    Handling routines are only of interest to the kernel
  288.  */
  289. #include <linux/slab.h>
  290.  
  291. #include <asm/system.h>
  292.  
  293. extern void           __kfree_skb(struct sk_buff *skb);
  294. extern struct sk_buff *alloc_skb(unsigned int size, int priority);
  295. extern struct sk_buff *alloc_skb_from_cache(kmem_cache_t *cp,
  296.                         unsigned int size, int priority);
  297. extern void           kfree_skbmem(struct sk_buff *skb);
  298. extern struct sk_buff *skb_clone(struct sk_buff *skb, int priority);
  299. extern struct sk_buff *skb_copy(const struct sk_buff *skb, int priority);
  300. extern struct sk_buff *pskb_copy(struct sk_buff *skb, int gfp_mask);
  301. extern int           pskb_expand_head(struct sk_buff *skb,
  302.                     int nhead, int ntail, int gfp_mask);
  303. extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
  304.                         unsigned int headroom);
  305. extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
  306.                        int newheadroom, int newtailroom,
  307.                        int priority);
  308. extern struct sk_buff *        skb_pad(struct sk_buff *skb, int pad);
  309. #define dev_kfree_skb(a)    kfree_skb(a)
  310. extern void          skb_over_panic(struct sk_buff *skb, int len,
  311.                      void *here);
  312. extern void          skb_under_panic(struct sk_buff *skb, int len,
  313.                       void *here);
  314.  
  315. /* Internal */
  316. #define skb_shinfo(SKB)        ((struct skb_shared_info *)((SKB)->end))
  317.  
  318. /**
  319.  *    skb_queue_empty - check if a queue is empty
  320.  *    @list: queue head
  321.  *
  322.  *    Returns true if the queue is empty, false otherwise.
  323.  */
  324. static inline int skb_queue_empty(const struct sk_buff_head *list)
  325. {
  326.     return list->next == (struct sk_buff *)list;
  327. }
  328.  
  329. /**
  330.  *    skb_get - reference buffer
  331.  *    @skb: buffer to reference
  332.  *
  333.  *    Makes another reference to a socket buffer and returns a pointer
  334.  *    to the buffer.
  335.  */
  336. static inline struct sk_buff *skb_get(struct sk_buff *skb)
  337. {
  338.     atomic_inc(&skb->users);
  339.     return skb;
  340. }
  341.  
  342. /*
  343.  * If users == 1, we are the only owner and are can avoid redundant
  344.  * atomic change.
  345.  */
  346.  
  347. /**
  348.  *    kfree_skb - free an sk_buff
  349.  *    @skb: buffer to free
  350.  *
  351.  *    Drop a reference to the buffer and free it if the usage count has
  352.  *    hit zero.
  353.  */
  354. static inline void kfree_skb(struct sk_buff *skb)
  355. {
  356.     if (likely(atomic_read(&skb->users) == 1))
  357.         smp_rmb();
  358.     else if (likely(!atomic_dec_and_test(&skb->users)))
  359.         return;
  360.     __kfree_skb(skb);
  361. }
  362.  
  363. /**
  364.  *    skb_cloned - is the buffer a clone
  365.  *    @skb: buffer to check
  366.  *
  367.  *    Returns true if the buffer was generated with skb_clone() and is
  368.  *    one of multiple shared copies of the buffer. Cloned buffers are
  369.  *    shared data so must not be written to under normal circumstances.
  370.  */
  371. static inline int skb_cloned(const struct sk_buff *skb)
  372. {
  373.     return skb->cloned && atomic_read(&skb_shinfo(skb)->dataref) != 1;
  374. }
  375.  
  376. /**
  377.  *    skb_shared - is the buffer shared
  378.  *    @skb: buffer to check
  379.  *
  380.  *    Returns true if more than one person has a reference to this
  381.  *    buffer.
  382.  */
  383. static inline int skb_shared(const struct sk_buff *skb)
  384. {
  385.     return atomic_read(&skb->users) != 1;
  386. }
  387.  
  388. /**
  389.  *    skb_share_check - check if buffer is shared and if so clone it
  390.  *    @skb: buffer to check
  391.  *    @pri: priority for memory allocation
  392.  *
  393.  *    If the buffer is shared the buffer is cloned and the old copy
  394.  *    drops a reference. A new clone with a single reference is returned.
  395.  *    If the buffer is not shared the original buffer is returned. When
  396.  *    being called from interrupt status or with spinlocks held pri must
  397.  *    be GFP_ATOMIC.
  398.  *
  399.  *    NULL is returned on a memory allocation failure.
  400.  */
  401. static inline struct sk_buff *skb_share_check(struct sk_buff *skb, int pri)
  402. {
  403.     might_sleep_if(pri & __GFP_WAIT);
  404.     if (skb_shared(skb)) {
  405.         struct sk_buff *nskb = skb_clone(skb, pri);
  406.         kfree_skb(skb);
  407.         skb = nskb;
  408.     }
  409.     return skb;
  410. }
  411.  
  412. /*
  413.  *    Copy shared buffers into a new sk_buff. We effectively do COW on
  414.  *    packets to handle cases where we have a local reader and forward
  415.  *    and a couple of other messy ones. The normal one is tcpdumping
  416.  *    a packet thats being forwarded.
  417.  */
  418.  
  419. /**
  420.  *    skb_unshare - make a copy of a shared buffer
  421.  *    @skb: buffer to check
  422.  *    @pri: priority for memory allocation
  423.  *
  424.  *    If the socket buffer is a clone then this function creates a new
  425.  *    copy of the data, drops a reference count on the old copy and returns
  426.  *    the new copy with the reference count at 1. If the buffer is not a clone
  427.  *    the original buffer is returned. When called with a spinlock held or
  428.  *    from interrupt state @pri must be %GFP_ATOMIC
  429.  *
  430.  *    %NULL is returned on a memory allocation failure.
  431.  */
  432. static inline struct sk_buff *skb_unshare(struct sk_buff *skb, int pri)
  433. {
  434.     might_sleep_if(pri & __GFP_WAIT);
  435.     if (skb_cloned(skb)) {
  436.         struct sk_buff *nskb = skb_copy(skb, pri);
  437.         kfree_skb(skb);    /* Free our shared copy */
  438.         skb = nskb;
  439.     }
  440.     return skb;
  441. }
  442.  
  443. /**
  444.  *    skb_peek
  445.  *    @list_: list to peek at
  446.  *
  447.  *    Peek an &sk_buff. Unlike most other operations you _MUST_
  448.  *    be careful with this one. A peek leaves the buffer on the
  449.  *    list and someone else may run off with it. You must hold
  450.  *    the appropriate locks or have a private queue to do this.
  451.  *
  452.  *    Returns %NULL for an empty list or a pointer to the head element.
  453.  *    The reference count is not incremented and the reference is therefore
  454.  *    volatile. Use with caution.
  455.  */
  456. static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)
  457. {
  458.     struct sk_buff *list = ((struct sk_buff *)list_)->next;
  459.     if (list == (struct sk_buff *)list_)
  460.         list = NULL;
  461.     return list;
  462. }
  463.  
  464. /**
  465.  *    skb_peek_tail
  466.  *    @list_: list to peek at
  467.  *
  468.  *    Peek an &sk_buff. Unlike most other operations you _MUST_
  469.  *    be careful with this one. A peek leaves the buffer on the
  470.  *    list and someone else may run off with it. You must hold
  471.  *    the appropriate locks or have a private queue to do this.
  472.  *
  473.  *    Returns %NULL for an empty list or a pointer to the tail element.
  474.  *    The reference count is not incremented and the reference is therefore
  475.  *    volatile. Use with caution.
  476.  */
  477. static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
  478. {
  479.     struct sk_buff *list = ((struct sk_buff *)list_)->prev;
  480.     if (list == (struct sk_buff *)list_)
  481.         list = NULL;
  482.     return list;
  483. }
  484.  
  485. /**
  486.  *    skb_queue_len    - get queue length
  487.  *    @list_: list to measure
  488.  *
  489.  *    Return the length of an &sk_buff queue.
  490.  */
  491. static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
  492. {
  493.     return list_->qlen;
  494. }
  495.  
  496. static inline void skb_queue_head_init(struct sk_buff_head *list)
  497. {
  498.     spin_lock_init(&list->lock);
  499.     list->prev = list->next = (struct sk_buff *)list;
  500.     list->qlen = 0;
  501. }
  502.  
  503. /*
  504.  *    Insert an sk_buff at the start of a list.
  505.  *
  506.  *    The "__skb_xxxx()" functions are the non-atomic ones that
  507.  *    can only be called with interrupts disabled.
  508.  */
  509.  
  510. /**
  511.  *    __skb_queue_head - queue a buffer at the list head
  512.  *    @list: list to use
  513.  *    @newsk: buffer to queue
  514.  *
  515.  *    Queue a buffer at the start of a list. This function takes no locks
  516.  *    and you must therefore hold required locks before calling it.
  517.  *
  518.  *    A buffer cannot be placed on two lists at the same time.
  519.  */
  520. extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
  521. static inline void __skb_queue_head(struct sk_buff_head *list,
  522.                     struct sk_buff *newsk)
  523. {
  524.     struct sk_buff *prev, *next;
  525.  
  526.     newsk->list = list;
  527.     list->qlen++;
  528.     prev = (struct sk_buff *)list;
  529.     next = prev->next;
  530.     newsk->next = next;
  531.     newsk->prev = prev;
  532.     next->prev  = prev->next = newsk;
  533. }
  534.  
  535. /**
  536.  *    __skb_queue_tail - queue a buffer at the list tail
  537.  *    @list: list to use
  538.  *    @newsk: buffer to queue
  539.  *
  540.  *    Queue a buffer at the end of a list. This function takes no locks
  541.  *    and you must therefore hold required locks before calling it.
  542.  *
  543.  *    A buffer cannot be placed on two lists at the same time.
  544.  */
  545. extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
  546. static inline void __skb_queue_tail(struct sk_buff_head *list,
  547.                    struct sk_buff *newsk)
  548. {
  549.     struct sk_buff *prev, *next;
  550.  
  551.     newsk->list = list;
  552.     list->qlen++;
  553.     next = (struct sk_buff *)list;
  554.     prev = next->prev;
  555.     newsk->next = next;
  556.     newsk->prev = prev;
  557.     next->prev  = prev->next = newsk;
  558. }
  559.  
  560.  
  561. /**
  562.  *    __skb_dequeue - remove from the head of the queue
  563.  *    @list: list to dequeue from
  564.  *
  565.  *    Remove the head of the list. This function does not take any locks
  566.  *    so must be used with appropriate locks held only. The head item is
  567.  *    returned or %NULL if the list is empty.
  568.  */
  569. extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
  570. static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
  571. {
  572.     struct sk_buff *next, *prev, *result;
  573.  
  574.     prev = (struct sk_buff *) list;
  575.     next = prev->next;
  576.     result = NULL;
  577.     if (next != prev) {
  578.         result         = next;
  579.         next         = next->next;
  580.         list->qlen--;
  581.         next->prev   = prev;
  582.         prev->next   = next;
  583.         result->next = result->prev = NULL;
  584.         result->list = NULL;
  585.     }
  586.     return result;
  587. }
  588.  
  589.  
  590. /*
  591.  *    Insert a packet on a list.
  592.  */
  593. extern void        skb_insert(struct sk_buff *old, struct sk_buff *newsk);
  594. static inline void __skb_insert(struct sk_buff *newsk,
  595.                 struct sk_buff *prev, struct sk_buff *next,
  596.                 struct sk_buff_head *list)
  597. {
  598.     newsk->next = next;
  599.     newsk->prev = prev;
  600.     next->prev  = prev->next = newsk;
  601.     newsk->list = list;
  602.     list->qlen++;
  603. }
  604.  
  605. /*
  606.  *    Place a packet after a given packet in a list.
  607.  */
  608. extern void       skb_append(struct sk_buff *old, struct sk_buff *newsk);
  609. static inline void __skb_append(struct sk_buff *old, struct sk_buff *newsk)
  610. {
  611.     __skb_insert(newsk, old, old->next, old->list);
  612. }
  613.  
  614. /*
  615.  * remove sk_buff from list. _Must_ be called atomically, and with
  616.  * the list known..
  617.  */
  618. extern void       skb_unlink(struct sk_buff *skb);
  619. static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
  620. {
  621.     struct sk_buff *next, *prev;
  622.  
  623.     list->qlen--;
  624.     next       = skb->next;
  625.     prev       = skb->prev;
  626.     skb->next  = skb->prev = NULL;
  627.     skb->list  = NULL;
  628.     next->prev = prev;
  629.     prev->next = next;
  630. }
  631.  
  632.  
  633. /* XXX: more streamlined implementation */
  634.  
  635. /**
  636.  *    __skb_dequeue_tail - remove from the tail of the queue
  637.  *    @list: list to dequeue from
  638.  *
  639.  *    Remove the tail of the list. This function does not take any locks
  640.  *    so must be used with appropriate locks held only. The tail item is
  641.  *    returned or %NULL if the list is empty.
  642.  */
  643. extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
  644. static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
  645. {
  646.     struct sk_buff *skb = skb_peek_tail(list);
  647.     if (skb)
  648.         __skb_unlink(skb, list);
  649.     return skb;
  650. }
  651.  
  652.  
  653. static inline int skb_is_nonlinear(const struct sk_buff *skb)
  654. {
  655.     return skb->data_len;
  656. }
  657.  
  658. static inline unsigned int skb_headlen(const struct sk_buff *skb)
  659. {
  660.     return skb->len - skb->data_len;
  661. }
  662.  
  663. static inline int skb_pagelen(const struct sk_buff *skb)
  664. {
  665.     int i, len = 0;
  666.  
  667.     for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
  668.         len += skb_shinfo(skb)->frags[i].size;
  669.     return len + skb_headlen(skb);
  670. }
  671.  
  672. static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
  673.                       struct page *page, int off, int size)
  674. {
  675.     skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
  676.  
  677.     frag->page          = page;
  678.     frag->page_offset      = off;
  679.     frag->size          = size;
  680.     skb_shinfo(skb)->nr_frags = i + 1;
  681. }
  682.  
  683. #define SKB_PAGE_ASSERT(skb)     BUG_ON(skb_shinfo(skb)->nr_frags)
  684. #define SKB_FRAG_ASSERT(skb)     BUG_ON(skb_shinfo(skb)->frag_list)
  685. #define SKB_LINEAR_ASSERT(skb)  BUG_ON(skb_is_nonlinear(skb))
  686.  
  687. /*
  688.  *    Add data to an sk_buff
  689.  */
  690. static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
  691. {
  692.     unsigned char *tmp = skb->tail;
  693.     SKB_LINEAR_ASSERT(skb);
  694.     skb->tail += len;
  695.     skb->len  += len;
  696.     return tmp;
  697. }
  698.  
  699. /**
  700.  *    skb_put - add data to a buffer
  701.  *    @skb: buffer to use
  702.  *    @len: amount of data to add
  703.  *
  704.  *    This function extends the used data area of the buffer. If this would
  705.  *    exceed the total buffer size the kernel will panic. A pointer to the
  706.  *    first byte of the extra data is returned.
  707.  */
  708. static inline unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
  709. {
  710.     unsigned char *tmp = skb->tail;
  711.     SKB_LINEAR_ASSERT(skb);
  712.     skb->tail += len;
  713.     skb->len  += len;
  714.     if (unlikely(skb->tail>skb->end))
  715.         skb_over_panic(skb, len, current_text_addr());
  716.     return tmp;
  717. }
  718.  
  719. static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
  720. {
  721.     skb->data -= len;
  722.     skb->len  += len;
  723.     return skb->data;
  724. }
  725.  
  726. /**
  727.  *    skb_push - add data to the start of a buffer
  728.  *    @skb: buffer to use
  729.  *    @len: amount of data to add
  730.  *
  731.  *    This function extends the used data area of the buffer at the buffer
  732.  *    start. If this would exceed the total buffer headroom the kernel will
  733.  *    panic. A pointer to the first byte of the extra data is returned.
  734.  */
  735. static inline unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
  736. {
  737.     skb->data -= len;
  738.     skb->len  += len;
  739.     if (unlikely(skb->data<skb->head))
  740.         skb_under_panic(skb, len, current_text_addr());
  741.     return skb->data;
  742. }
  743.  
  744. static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
  745. {
  746.     skb->len -= len;
  747.     BUG_ON(skb->len < skb->data_len);
  748.     return skb->data += len;
  749. }
  750.  
  751. /**
  752.  *    skb_pull - remove data from the start of a buffer
  753.  *    @skb: buffer to use
  754.  *    @len: amount of data to remove
  755.  *
  756.  *    This function removes data from the start of a buffer, returning
  757.  *    the memory to the headroom. A pointer to the next data in the buffer
  758.  *    is returned. Once the data has been pulled future pushes will overwrite
  759.  *    the old data.
  760.  */
  761. static inline unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
  762. {
  763.     return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
  764. }
  765.  
  766. extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
  767.  
  768. static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
  769. {
  770.     if (len > skb_headlen(skb) &&
  771.         !__pskb_pull_tail(skb, len-skb_headlen(skb)))
  772.         return NULL;
  773.     skb->len -= len;
  774.     return skb->data += len;
  775. }
  776.  
  777. static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
  778. {
  779.     return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
  780. }
  781.  
  782. static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
  783. {
  784.     if (likely(len <= skb_headlen(skb)))
  785.         return 1;
  786.     if (unlikely(len > skb->len))
  787.         return 0;
  788.     return __pskb_pull_tail(skb, len-skb_headlen(skb)) != NULL;
  789. }
  790.  
  791. /**
  792.  *    skb_headroom - bytes at buffer head
  793.  *    @skb: buffer to check
  794.  *
  795.  *    Return the number of bytes of free space at the head of an &sk_buff.
  796.  */
  797. static inline int skb_headroom(const struct sk_buff *skb)
  798. {
  799.     return skb->data - skb->head;
  800. }
  801.  
  802. /**
  803.  *    skb_tailroom - bytes at buffer end
  804.  *    @skb: buffer to check
  805.  *
  806.  *    Return the number of bytes of free space at the tail of an sk_buff
  807.  */
  808. static inline int skb_tailroom(const struct sk_buff *skb)
  809. {
  810.     return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
  811. }
  812.  
  813. /**
  814.  *    skb_reserve - adjust headroom
  815.  *    @skb: buffer to alter
  816.  *    @len: bytes to move
  817.  *
  818.  *    Increase the headroom of an empty &sk_buff by reducing the tail
  819.  *    room. This is only allowed for an empty buffer.
  820.  */
  821. static inline void skb_reserve(struct sk_buff *skb, unsigned int len)
  822. {
  823.     skb->data += len;
  824.     skb->tail += len;
  825. }
  826.  
  827. /*
  828.  * CPUs often take a performance hit when accessing unaligned memory
  829.  * locations. The actual performance hit varies, it can be small if the
  830.  * hardware handles it or large if we have to take an exception and fix it
  831.  * in software.
  832.  *
  833.  * Since an ethernet header is 14 bytes network drivers often end up with
  834.  * the IP header at an unaligned offset. The IP header can be aligned by
  835.  * shifting the start of the packet by 2 bytes. Drivers should do this
  836.  * with:
  837.  *
  838.  * skb_reserve(NET_IP_ALIGN);
  839.  *
  840.  * The downside to this alignment of the IP header is that the DMA is now
  841.  * unaligned. On some architectures the cost of an unaligned DMA is high
  842.  * and this cost outweighs the gains made by aligning the IP header.
  843.  * 
  844.  * Since this trade off varies between architectures, we allow NET_IP_ALIGN
  845.  * to be overridden.
  846.  */
  847. #ifndef NET_IP_ALIGN
  848. #define NET_IP_ALIGN    2
  849. #endif
  850.  
  851. extern int ___pskb_trim(struct sk_buff *skb, unsigned int len, int realloc);
  852.  
  853. static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
  854. {
  855.     if (!skb->data_len) {
  856.         skb->len  = len;
  857.         skb->tail = skb->data + len;
  858.     } else
  859.         ___pskb_trim(skb, len, 0);
  860. }
  861.  
  862. /**
  863.  *    skb_trim - remove end from a buffer
  864.  *    @skb: buffer to alter
  865.  *    @len: new length
  866.  *
  867.  *    Cut the length of a buffer down by removing data from the tail. If
  868.  *    the buffer is already under the length specified it is not modified.
  869.  */
  870. static inline void skb_trim(struct sk_buff *skb, unsigned int len)
  871. {
  872.     if (skb->len > len)
  873.         __skb_trim(skb, len);
  874. }
  875.  
  876.  
  877. static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
  878. {
  879.     if (!skb->data_len) {
  880.         skb->len  = len;
  881.         skb->tail = skb->data+len;
  882.         return 0;
  883.     }
  884.     return ___pskb_trim(skb, len, 1);
  885. }
  886.  
  887. static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
  888. {
  889.     return (len < skb->len) ? __pskb_trim(skb, len) : 0;
  890. }
  891.  
  892. /**
  893.  *    skb_orphan - orphan a buffer
  894.  *    @skb: buffer to orphan
  895.  *
  896.  *    If a buffer currently has an owner then we call the owner's
  897.  *    destructor function and make the @skb unowned. The buffer continues
  898.  *    to exist but is no longer charged to its former owner.
  899.  */
  900. static inline void skb_orphan(struct sk_buff *skb)
  901. {
  902.     if (skb->destructor)
  903.         skb->destructor(skb);
  904.     skb->destructor = NULL;
  905.     skb->sk        = NULL;
  906. }
  907.  
  908. /**
  909.  *    __skb_queue_purge - empty a list
  910.  *    @list: list to empty
  911.  *
  912.  *    Delete all buffers on an &sk_buff list. Each buffer is removed from
  913.  *    the list and one reference dropped. This function does not take the
  914.  *    list lock and the caller must hold the relevant locks to use it.
  915.  */
  916. extern void skb_queue_purge(struct sk_buff_head *list);
  917. static inline void __skb_queue_purge(struct sk_buff_head *list)
  918. {
  919.     struct sk_buff *skb;
  920.     while ((skb = __skb_dequeue(list)) != NULL)
  921.         kfree_skb(skb);
  922. }
  923.  
  924. /**
  925.  *    __dev_alloc_skb - allocate an skbuff for sending
  926.  *    @length: length to allocate
  927.  *    @gfp_mask: get_free_pages mask, passed to alloc_skb
  928.  *
  929.  *    Allocate a new &sk_buff and assign it a usage count of one. The
  930.  *    buffer has unspecified headroom built in. Users should allocate
  931.  *    the headroom they think they need without accounting for the
  932.  *    built in space. The built in space is used for optimisations.
  933.  *
  934.  *    %NULL is returned in there is no free memory.
  935.  */
  936. #ifndef CONFIG_HAVE_ARCH_DEV_ALLOC_SKB
  937. static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
  938.                           int gfp_mask)
  939. {
  940.     struct sk_buff *skb = alloc_skb(length + 16, gfp_mask);
  941.     if (likely(skb))
  942.         skb_reserve(skb, 16);
  943.     return skb;
  944. }
  945. #else
  946. extern struct sk_buff *__dev_alloc_skb(unsigned int length, int gfp_mask);
  947. #endif
  948.  
  949. /**
  950.  *    dev_alloc_skb - allocate an skbuff for sending
  951.  *    @length: length to allocate
  952.  *
  953.  *    Allocate a new &sk_buff and assign it a usage count of one. The
  954.  *    buffer has unspecified headroom built in. Users should allocate
  955.  *    the headroom they think they need without accounting for the
  956.  *    built in space. The built in space is used for optimisations.
  957.  *
  958.  *    %NULL is returned in there is no free memory. Although this function
  959.  *    allocates memory it can be called from an interrupt.
  960.  */
  961. static inline struct sk_buff *dev_alloc_skb(unsigned int length)
  962. {
  963.     return __dev_alloc_skb(length, GFP_ATOMIC);
  964. }
  965.  
  966. /**
  967.  *    skb_cow - copy header of skb when it is required
  968.  *    @skb: buffer to cow
  969.  *    @headroom: needed headroom
  970.  *
  971.  *    If the skb passed lacks sufficient headroom or its data part
  972.  *    is shared, data is reallocated. If reallocation fails, an error
  973.  *    is returned and original skb is not changed.
  974.  *
  975.  *    The result is skb with writable area skb->head...skb->tail
  976.  *    and at least @headroom of space at head.
  977.  */
  978. static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
  979. {
  980.     int delta = (headroom > 16 ? headroom : 16) - skb_headroom(skb);
  981.  
  982.     if (delta < 0)
  983.         delta = 0;
  984.  
  985.     if (delta || skb_cloned(skb))
  986.         return pskb_expand_head(skb, (delta + 15) & ~15, 0, GFP_ATOMIC);
  987.     return 0;
  988. }
  989.  
  990. /**
  991.  *    skb_padto    - pad an skbuff up to a minimal size
  992.  *    @skb: buffer to pad
  993.  *    @len: minimal length
  994.  *
  995.  *    Pads up a buffer to ensure the trailing bytes exist and are
  996.  *    blanked. If the buffer already contains sufficient data it
  997.  *    is untouched. Returns the buffer, which may be a replacement
  998.  *    for the original, or NULL for out of memory - in which case
  999.  *    the original buffer is still freed.
  1000.  */
  1001.  
  1002. static inline struct sk_buff *skb_padto(struct sk_buff *skb, unsigned int len)
  1003. {
  1004.     unsigned int size = skb->len;
  1005.     if (likely(size >= len))
  1006.         return skb;
  1007.     return skb_pad(skb, len-size);
  1008. }
  1009.  
  1010. static inline int skb_add_data(struct sk_buff *skb,
  1011.                    char __user *from, int copy)
  1012. {
  1013.     const int off = skb->len;
  1014.  
  1015.     if (skb->ip_summed == CHECKSUM_NONE) {
  1016.         int err = 0;
  1017.         unsigned int csum = csum_and_copy_from_user(from,
  1018.                                 skb_put(skb, copy),
  1019.                                 copy, 0, &err);
  1020.         if (!err) {
  1021.             skb->csum = csum_block_add(skb->csum, csum, off);
  1022.             return 0;
  1023.         }
  1024.     } else if (!copy_from_user(skb_put(skb, copy), from, copy))
  1025.         return 0;
  1026.  
  1027.     __skb_trim(skb, off);
  1028.     return -EFAULT;
  1029. }
  1030.  
  1031. static inline int skb_can_coalesce(struct sk_buff *skb, int i,
  1032.                    struct page *page, int off)
  1033. {
  1034.     if (i) {
  1035.         struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
  1036.  
  1037.         return page == frag->page &&
  1038.                off == frag->page_offset + frag->size;
  1039.     }
  1040.     return 0;
  1041. }
  1042.  
  1043. /**
  1044.  *    skb_linearize - convert paged skb to linear one
  1045.  *    @skb: buffer to linarize
  1046.  *    @gfp: allocation mode
  1047.  *
  1048.  *    If there is no free memory -ENOMEM is returned, otherwise zero
  1049.  *    is returned and the old skb data released.
  1050.  */
  1051. extern int __skb_linearize(struct sk_buff *skb, int gfp);
  1052. static inline int skb_linearize(struct sk_buff *skb, int gfp)
  1053. {
  1054.     return __skb_linearize(skb, gfp);
  1055. }
  1056.  
  1057. static inline void *kmap_skb_frag(const skb_frag_t *frag)
  1058. {
  1059. #ifdef CONFIG_HIGHMEM
  1060.     BUG_ON(in_irq());
  1061.  
  1062.     local_bh_disable();
  1063. #endif
  1064.     return kmap_atomic(frag->page, KM_SKB_DATA_SOFTIRQ);
  1065. }
  1066.  
  1067. static inline void kunmap_skb_frag(void *vaddr)
  1068. {
  1069.     kunmap_atomic(vaddr, KM_SKB_DATA_SOFTIRQ);
  1070. #ifdef CONFIG_HIGHMEM
  1071.     local_bh_enable();
  1072. #endif
  1073. }
  1074.  
  1075. #define skb_queue_walk(queue, skb) \
  1076.         for (skb = (queue)->next;                    \
  1077.              prefetch(skb->next), (skb != (struct sk_buff *)(queue));    \
  1078.              skb = skb->next)
  1079.  
  1080.  
  1081. extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
  1082.                      int noblock, int *err);
  1083. extern unsigned int    datagram_poll(struct file *file, struct socket *sock,
  1084.                      struct poll_table_struct *wait);
  1085. extern int           skb_copy_datagram_iovec(const struct sk_buff *from,
  1086.                            int offset, struct iovec *to,
  1087.                            int size);
  1088. extern int           skb_copy_and_csum_datagram_iovec(const
  1089.                             struct sk_buff *skb,
  1090.                             int hlen,
  1091.                             struct iovec *iov);
  1092. extern void           skb_free_datagram(struct sock *sk, struct sk_buff *skb);
  1093. extern unsigned int    skb_checksum(const struct sk_buff *skb, int offset,
  1094.                     int len, unsigned int csum);
  1095. extern int           skb_copy_bits(const struct sk_buff *skb, int offset,
  1096.                      void *to, int len);
  1097. extern unsigned int    skb_copy_and_csum_bits(const struct sk_buff *skb,
  1098.                           int offset, u8 *to, int len,
  1099.                           unsigned int csum);
  1100. extern void           skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
  1101. extern void           skb_split(struct sk_buff *skb,
  1102.                  struct sk_buff *skb1, const u32 len);
  1103.  
  1104. static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
  1105.                        int len, void *buffer)
  1106. {
  1107.     int hlen = skb_headlen(skb);
  1108.  
  1109.     if (offset + len <= hlen)
  1110.         return skb->data + offset;
  1111.  
  1112.     if (skb_copy_bits(skb, offset, buffer, len) < 0)
  1113.         return NULL;
  1114.  
  1115.     return buffer;
  1116. }
  1117.  
  1118. extern void skb_init(void);
  1119. extern void skb_add_mtu(int mtu);
  1120.  
  1121. struct skb_iter {
  1122.     /* Iteration functions set these */
  1123.     unsigned char *data;
  1124.     unsigned int len;
  1125.  
  1126.     /* Private to iteration */
  1127.     unsigned int nextfrag;
  1128.     struct sk_buff *fraglist;
  1129. };
  1130.  
  1131. /* Keep iterating until skb_iter_next returns false. */
  1132. extern void skb_iter_first(const struct sk_buff *skb, struct skb_iter *i);
  1133. extern int skb_iter_next(const struct sk_buff *skb, struct skb_iter *i);
  1134. /* Call this if aborting loop before !skb_iter_next */
  1135. extern void skb_iter_abort(const struct sk_buff *skb, struct skb_iter *i);
  1136.  
  1137. #ifdef CONFIG_NETFILTER
  1138. static inline void nf_conntrack_put(struct nf_conntrack *nfct)
  1139. {
  1140.     if (nfct && atomic_dec_and_test(&nfct->use))
  1141.         nfct->destroy(nfct);
  1142. }
  1143. static inline void nf_conntrack_get(struct nf_conntrack *nfct)
  1144. {
  1145.     if (nfct)
  1146.         atomic_inc(&nfct->use);
  1147. }
  1148. static inline void nf_reset(struct sk_buff *skb)
  1149. {
  1150.     nf_conntrack_put(skb->nfct);
  1151.     skb->nfct = NULL;
  1152. #ifdef CONFIG_NETFILTER_DEBUG
  1153.     skb->nf_debug = 0;
  1154. #endif
  1155. }
  1156. static inline void nf_reset_debug(struct sk_buff *skb)
  1157. {
  1158. #ifdef CONFIG_NETFILTER_DEBUG
  1159.     skb->nf_debug = 0;
  1160. #endif
  1161. }
  1162.  
  1163. #ifdef CONFIG_BRIDGE_NETFILTER
  1164. static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
  1165. {
  1166.     if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
  1167.         kfree(nf_bridge);
  1168. }
  1169. static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
  1170. {
  1171.     if (nf_bridge)
  1172.         atomic_inc(&nf_bridge->use);
  1173. }
  1174. #endif /* CONFIG_BRIDGE_NETFILTER */
  1175. #else /* CONFIG_NETFILTER */
  1176. static inline void nf_reset(struct sk_buff *skb) {}
  1177. #endif /* CONFIG_NETFILTER */
  1178.  
  1179. #endif    /* __KERNEL__ */
  1180. #endif    /* _LINUX_SKBUFF_H */
  1181.